home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / programm.ing / m2posx10.zoo / m2posix.10 / src / memblk.ipp < prev    next >
Encoding:
Modula Implementation  |  1993-12-02  |  23.1 KB  |  874 lines
  1. IMPLEMENTATION MODULE MEMBLK;
  2. __IMP_SWITCHES__
  3. #ifdef HM2
  4. #ifdef __LONG_WHOLE__
  5. (*$!i+: Modul muss mit $i- uebersetzt werden! *)
  6. (*$!w+: Modul muss mit $w- uebersetzt werden! *)
  7. #else
  8. (*$!i-: Modul muss mit $i+ uebersetzt werden! *)
  9. (*$!w-: Modul muss mit $w+ uebersetzt werden! *)
  10. #endif
  11. #endif
  12. (*****************************************************************************)
  13. (* 28-Sep-93, Holger Kleinschmidt                                            *)
  14. (*****************************************************************************)
  15.  
  16. INLINE_CODE_IMPORT
  17.  
  18. FROM SYSTEM IMPORT
  19. (* TYPE *) ADDRESS;
  20.  
  21. FROM types IMPORT
  22. (* TYPE *) sizeT;
  23.  
  24. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  25.  
  26. __PROCFRAME_OFF__
  27. PROCEDURE memswap ((* EIN/ -- *) blk1 : ADDRESS;
  28.                    (* EIN/ -- *) blk2 : ADDRESS;
  29.                    (* EIN/ -- *) len  : sizeT   );
  30. (*T*)
  31. BEGIN
  32. #if (defined HM2)
  33. (*
  34.   move.w  D2,-(SP)
  35.   movea.l 6(SP),A0
  36.   movea.l 10(SP),A1
  37.   move.l  14(SP),D0
  38. *)
  39.  CODE(3F02H,206FH,0006H,226FH,000AH,202FH,000EH);
  40. #elif (defined MM2)
  41. (*
  42.   move.l  -(A3),D0
  43.   movea.l -(A3),A1
  44.   movea.l -(A3),A0
  45.   tst.l   D0
  46. *)
  47.  CODE(2023H,2263H,2063H,4A80H);
  48. #elif (defined TDIM2)
  49. (*
  50.   movea.l 12(SP),A0
  51.   movea.l 8(SP),A1
  52.   move.l  4(SP),D0
  53. *)
  54.  CODE(206FH,000CH,226FH,0008H,202FH,0004H);
  55. #elif (defined LPRM2) || (defined SPCM2)
  56. (*
  57.   movea.l 20(A6),A0
  58.   movea.l 16(A6),A1
  59.   move.l  12(A6),D0
  60. *)
  61.  CODE(206EH,0014H,226EH,0010H,202EH,000CH);
  62. #endif
  63.  
  64. (*
  65.   beq.s   ende           ; B: len = 0, nix zu tun
  66.   move.w  A0,D1
  67.   move.w  A1,D2
  68.   eor.b   D2,D1          ; genau eine der Adressen ungerade ?
  69.   btst    #0,D1          ;
  70.   beq.s   fastswap       ; B: nein
  71. slowswap:                ; Bloecke byteweise vertauschen
  72.   move.b  (A0),D1
  73.   move.b  (A1),(A0)+
  74.   move.b  D1,(A1)+
  75.   subq.l  #1,D0
  76.   bne.s   slowswap
  77.   bra.s   ende           ; fertig
  78.  
  79. fastswap:
  80.   btst    #0,D2          ; beide Adr. ungerade oder beide gerade ?
  81.   beq.s   longcnt        ; B: beide gerade
  82.   move.b  (A0),D1        ; sonst ein Byte vorneweg tauschen
  83.   move.b  (A1),(A0)+     ; -> gerade Adresse
  84.   move.b  D1,(A1)+
  85.   subq.l  #1,D0          ; eins weniger zu tauschen
  86. longcnt:
  87.   move.b  D0,D2          ; fuer spaeteren Ueberhangtest
  88.   lsr.l   #2,D0          ; Anzahl auszutauschender Langworte
  89.   beq.s   tstwswap       ; B: weniger als 4 Byte
  90. swaplp:                  ; Bloecke langwortweise vertauschen
  91.   move.l  (A0),D1
  92.   move.l  (A1),(A0)+
  93.   move.l  D1,(A1)+
  94.   subq.l  #1,D0
  95.   bne.s   swaplp
  96. tstwswap:
  97.   btst    #1,D2          ; noch ein zusaetzl. Wort auszutauschen ?
  98.   beq.s   tstbswap       ; B: nein
  99.   move.w  (A0),D1
  100.   move.w  (A1),(A0)+
  101.   move.w  D1,(A1)+
  102. tstbswap:
  103.   btst    #0,D2          ; noch ein Byte ?
  104.   beq.s   ende           ; B: nein, fertig
  105.   move.b  (A0),D1
  106.   move.b  (A1),(A0)
  107.   move.b  D1,(A1)
  108. ende:
  109.  
  110. *)
  111.  CODE(674EH,3208H,3409H,0B501H,0801H,0000H);
  112.  CODE(670CH,1210H,10D1H,12C1H,5380H,66F6H,6036H,0802H);
  113.  CODE(0000H,6708H,1210H,10D1H,12C1H,5380H,1400H,0E488H);
  114.  CODE(670AH,2210H,20D1H,22C1H,5380H,66F6H,0802H,0001H);
  115.  CODE(6706H,3210H,30D1H,32C1H,0802H,0000H,6706H,1210H);
  116.  CODE(1091H,1281H);
  117.  
  118. #if (defined HM2)
  119. (*
  120.   move.w  (SP)+,D2
  121.   movea.l (SP)+,A0
  122.   lea     12(SP),SP
  123.   jmp     (A0)
  124. *)
  125.  CODE(341FH,205FH,4FEFH,000CH,4ED0H);
  126. #elif (defined TDIM2)
  127. (*
  128.   rts
  129. *)
  130.  CODE(4E75H);
  131. #endif
  132. END memswap;
  133. __PROCFRAME_ON__
  134.  
  135. (*---------------------------------------------------------------------------*)
  136.  
  137. __PROCFRAME_OFF__
  138. PROCEDURE memmove ((* EIN/ -- *) dst : ADDRESS;
  139.                    (* EIN/ -- *) src : ADDRESS;
  140.                    (* EIN/ -- *) len : sizeT   );
  141. (*T*)
  142. BEGIN
  143. #if (defined HM2)
  144. (*
  145.   move.w  D2,-(SP)
  146.   movea.l 10(SP),A0
  147.   movea.l 6(SP),A1
  148.   move.l  14(SP),D0
  149. *)
  150.  CODE(3F02H,206FH,000AH,226FH,0006H,202FH,000EH);
  151. #elif (defined MM2)
  152. (*
  153.   move.l  -(A3),D0
  154.   movea.l -(A3),A0
  155.   movea.l -(A3),A1
  156.   tst.l   D0
  157. *)
  158.  CODE(2023H,2063H,2263H,4A80H);
  159. #elif (defined TDIM2)
  160. (*
  161.   movea.l 8(SP),A0
  162.   movea.l 12(SP),A1
  163.   move.l  4(SP),D0
  164. *)
  165.  CODE(206FH,0008H,226FH,000CH,202FH,0004H);
  166. #elif (defined LPRM2) || (defined SPCM2)
  167. (*
  168.   movea.l 16(A6),A0
  169.   movea.l 20(A6),A1
  170.   move.l  12(A6),D0
  171. *)
  172.  CODE(206EH,0010H,226EH,0014H,202EH,000CH);
  173. #endif
  174.  
  175. (*
  176.   beq     ende           ; B: len = 0, nix zu tun
  177.   cmpa.l  A0,A1          ; Zieladresse groesser als Quelladresse ?
  178.   bhi     special        ; B: ja, muss von hinten nach vorne kopiert werden
  179.                          ; falls sich die Bereiche ueberschneiden
  180.   move.w  A0,D1          ; genau eine Adresse ungerade ?
  181.   move.w  A1,D2          ;
  182.   eor.b   D2,D1          ;
  183.   btst    #0,D1          ;
  184.   beq.s   nfastcpy       ; B: nein, beide gerade/ungerade -> schnell kopieren
  185.  
  186. * Es muss langsam byteweise kopiert werden.
  187. * Der Trick mit dem Sprung in die Kopieranweisungen stammt aus
  188. * dem "bcopy()" der GnuLib/MiNTLib
  189.  
  190.   move.w  D0,D1          ; die Anzahl Bytes im letzten unvollstaendigen 8-er-
  191.   neg.w   D1             ; Block und entsprechenden Index in die
  192.   andi.w  #7,D1          ; Kopieranweisungen berechnen
  193.   add.w   D1,D1          ;
  194.   addq.l  #7,D0          ; plus 1 Block, falls unvollst. Block
  195.   lsr.l   #3,D0          ; Anzahl kompletter 8-er Bloecke [+ unvollst. Block]
  196.   jmp     nloop8(PC,D1.w) ; ersten vollst. oder unvollst. Block kopieren
  197. nloop8:                  ; jeweils 8 Byte kopieren
  198.   move.b  (A0)+,(A1)+
  199.   move.b  (A0)+,(A1)+
  200.   move.b  (A0)+,(A1)+
  201.   move.b  (A0)+,(A1)+
  202.   move.b  (A0)+,(A1)+
  203.   move.b  (A0)+,(A1)+
  204.   move.b  (A0)+,(A1)+
  205.   move.b  (A0)+,(A1)+
  206.   subq.l  #1,D0
  207.   bne.s   nloop8
  208.   bra     ende
  209.  
  210. nfastcpy:
  211.   btst    #0,D2          ; beide Adressen ungerade ?
  212.   beq.s   neven          ; B: nein
  213.   move.b  (A0)+,(A1)+    ; ein Byte vorneweg -> gerade Adressen
  214.   subq.l  #1,D0          ; ein Byte weniger zu kopieren
  215. neven:
  216.   move.b  D0,D2          ; fuer spaeteren Ueberhangtest
  217.   lsr.l   #2,D0          ; Anzahl zu kopierender Langworte
  218.   beq.s   ntstw          ; B: weniger als 4 Byte
  219.   move.w  D0,D1          ; die Anzahl Bytes im letzten unvollstaendigen 32-er-
  220.   neg.w   D1             ; Block und entsprechenden Index in die
  221.   andi.w  #7,D1          ; Kopieranweisungen berechnen
  222.   add.w   D1,D1          ;
  223.   addq.l  #7,D0          ; plus 1 Block, falls unvollst. Block
  224.   lsr.l   #3,D0          ; Anzahl von 32-er-Bloecken [+ unvollst Block]
  225.   jmp     nloop32(PC,D1.w) ; ersten vollst. oder unvollst. Block kopieren
  226. nloop32:                 ; jeweils 32 Byte kopieren
  227.   move.l  (A0)+,(A1)+
  228.   move.l  (A0)+,(A1)+
  229.   move.l  (A0)+,(A1)+
  230.   move.l  (A0)+,(A1)+
  231.   move.l  (A0)+,(A1)+
  232.   move.l  (A0)+,(A1)+
  233.   move.l  (A0)+,(A1)+
  234.   move.l  (A0)+,(A1)+
  235.   subq.l  #1,D0
  236.   bne.s   nloop32
  237. ntstw:
  238.   btst    #1,D2          ; ein zusaetzliches Wort ?
  239.   beq.s   ntstb          ; B: nein
  240.   move.w  (A0)+,(A1)+
  241. ntstb:
  242.   btst    #0,D2          ; ein zusaetzliches Byte ?
  243.   beq     ende           ; B: nein, fertig
  244.   move.b  (A0)+,(A1)+
  245.   bra.s   ende
  246.  
  247. * wie oben, nur alles von hinten nach vorne kopieren
  248.  
  249. special:
  250.   adda.l  D0,A0
  251.   adda.l  D0,A1
  252.  
  253.   move.w  A0,D1
  254.   move.w  A1,D2
  255.   eor.b   D2,D1
  256.   btst    #0,D1
  257.   beq.s   sfastcpy
  258.  
  259.   move.w  D0,D1
  260.   neg.w   D1
  261.   andi.w  #7,D1
  262.   add.w   D1,D1
  263.   addq.l  #7,D0
  264.   lsr.l   #3,D0
  265.   jmp     sloop8(PC,D1.w)
  266. sloop8:
  267.   move.b  -(A0),-(A1)
  268.   move.b  -(A0),-(A1)
  269.   move.b  -(A0),-(A1)
  270.   move.b  -(A0),-(A1)
  271.   move.b  -(A0),-(A1)
  272.   move.b  -(A0),-(A1)
  273.   move.b  -(A0),-(A1)
  274.   move.b  -(A0),-(A1)
  275.   subq.l  #1,D0
  276.   bne.s   sloop8
  277.   bra.s   ende
  278.  
  279. sfastcpy:
  280.   btst    #0,D2
  281.   beq.s   seven
  282.   move.b  -(A0),-(A1)
  283.   subq.l  #1,D0
  284. seven:
  285.   move.b  D0,D2
  286.   lsr.l   #2,D0
  287.   beq.s   ststw
  288.   move.w  D0,D1
  289.   neg.w   D1
  290.   andi7.w  #7,D1
  291.   add.w   D1,D1
  292.   addq.l  #7,D0
  293.   lsr.l   #3,D0
  294.   jmp     sloop32(PC,D1.w)
  295. sloop32:
  296.   move.l  -(A0),-(A1)
  297.   move.l  -(A0),-(A1)
  298.   move.l  -(A0),-(A1)
  299.   move.l  -(A0),-(A1)
  300.   move.l  -(A0),-(A1)
  301.   move.l  -(A0),-(A1)
  302.   move.l  -(A0),-(A1)
  303.   move.l  -(A0),-(A1)
  304.   subq.l  #1,D0
  305.   bne.s   sloop32
  306. ststw:
  307.   btst    #1,D2
  308.   beq.s   ststb
  309.   move.w  -(A0),-(A1)
  310. ststb:
  311.   btst    #0,D2
  312.   beq.s   ende
  313.   move.b  -(A0),-(A1)
  314.  
  315. ende:
  316. *)
  317.  CODE(6700H,0106H,0B3C8H,6200H,0082H,3208H);
  318.  CODE(3409H,0B501H,0801H,0000H,672AH,3200H,4441H,0241H);
  319.  CODE(0007H,0D241H,5E80H,0E688H,4EFBH,1002H,12D8H,12D8H);
  320.  CODE(12D8H,12D8H,12D8H,12D8H,12D8H,12D8H,5380H,66ECH);
  321.  CODE(6000H,00CAH,0802H,0000H,6704H,12D8H,5380H,1400H);
  322.  CODE(0E488H,6726H,3200H,4441H,0241H,0007H,0D241H,5E80H);
  323.  CODE(0E688H,4EFBH,1002H,22D8H,22D8H,22D8H,22D8H,22D8H);
  324.  CODE(22D8H,22D8H,22D8H,5380H,66ECH,0802H,0001H,6702H);
  325.  CODE(32D8H,0802H,0000H,6700H,0084H,12D8H,607EH,0D1C0H);
  326.  CODE(0D3C0H,3208H,3409H,0B501H,0801H,0000H,6728H,3200H);
  327.  CODE(4441H,0241H,0007H,0D241H,5E80H,0E688H,4EFBH,1002H);
  328.  CODE(1320H,1320H,1320H,1320H,1320H,1320H,1320H,1320H);
  329.  CODE(5380H,66ECH,6046H,0802H,0000H,6704H,1320H,5380H);
  330.  CODE(1400H,0E488H,6726H,3200H,4441H,0241H,0007H,0D241H);
  331.  CODE(5E80H,0E688H,4EFBH,1002H,2320H,2320H,2320H,2320H);
  332.  CODE(2320H,2320H,2320H,2320H,5380H,66ECH,0802H,0001H);
  333.  CODE(6702H,3320H,0802H,0000H,6702H,1320H);
  334.  
  335. #if (defined HM2)
  336. (*
  337.   move.w  (SP)+,D2
  338.   movea.l (SP)+,A0
  339.   lea     12(SP),SP
  340.   jmp     (A0)
  341. *)
  342.  CODE(341FH,205FH,4FEFH,000CH,4ED0H);
  343. #elif (defined TDIM2)
  344. (*
  345.   rts
  346. *)
  347.  CODE(4E75H);
  348. #endif
  349. END memmove;
  350. __PROCFRAME_ON__
  351.  
  352. (*---------------------------------------------------------------------------*)
  353.  
  354. __PROCFRAME_OFF__
  355. PROCEDURE memset ((* EIN/ -- *) dst : ADDRESS;
  356.                   (* EIN/ -- *) val : CARDINAL;
  357.                   (* EIN/ -- *) len : sizeT    );
  358. (**)
  359. BEGIN
  360. #if (defined HM2)
  361. (*
  362.   move.w  D2,-(SP)
  363.   movea.l 6(SP),A0
  364. #if (defined __LONG_WHOLE__)
  365.   move.w  10+2(SP),D1
  366.   move.l  14(SP),D0
  367. #else
  368.   move.w  10(SP),D1
  369.   move.l  12(SP),D0
  370. #endif
  371. *)
  372.  CODE(3F02H,206FH,0006H);
  373. #if (defined __LONG_WHOLE__)
  374.  CODE(322FH,000CH,202FH,000EH);
  375. #else
  376.  CODE(322FH,000AH,202FH,000CH);
  377. #endif
  378. #elif (defined MM2)
  379. (*
  380.   move.l  -(A3),D0
  381. #if (defined __LONG_WHOLE__)
  382.   move.l  -(A3),D1
  383. #else
  384.   move.w  -(A3),D1
  385. #endif
  386.   movea.l -(A3),A0
  387.   tst.l   D0
  388. *)
  389.  CODE(2023H);
  390. #if (defined __LONG_WHOLE__)
  391.  CODE(2223H);
  392. #else
  393.  CODE(3223H);
  394. #endif
  395.  CODE(2063H,4A80H);
  396. #elif (defined TDIM2)
  397. (*
  398.   movea.l 10(SP),A0
  399.   move.w  8(SP),D1
  400.   move.l  4(SP),D0
  401. *)
  402.  CODE(206FH,000AH,322FH,0008H,202FH,0004H);
  403. #elif (defined LPRM2) || (defined SPCM2)
  404. (*
  405.   movea.l 18(A6),A0
  406.   move.w  16(A6),D1
  407.   move.l  12(A6),D0
  408. *)
  409.  CODE(206EH,0012H,322EH,0010H,202EH,000CH);
  410. #endif
  411.  
  412. (*
  413.   beq.s   ende           ; B: len = 0, nix zu tun
  414.  
  415.   move.b  D1,D2
  416.   lsl.w   #8,D2
  417.   move.b  D1,D2
  418.   move.w  D2,D1
  419.   swap    D1
  420.   move.w  D2,D1
  421.  
  422.   move.w  A0,D2          ; Anfangsadresse ungerade ?
  423.   btst    #0,D2          ;
  424.   beq.s   even           ; B: nein
  425.   move.b  D1,(A0)+       ; sonst ein Byte vorneweg kopieren
  426.   subq.l  #1,D0
  427. even:
  428.   movea.w D0,A1          ; Anzahl der Bytes fuer spaeteren Ueberhangtest merken
  429.   lsr.l   #2,D0          ; Anzahl von Langworten
  430.   beq.s   tstw           ; B: weniger als 4 Byte zu kopieren
  431.   move.w  D0,D2          ; die Anzahl Bytes im letzten unvollstaendigen 32-er-
  432.   neg.w   D2             ; Block und entsprechenden Index in die
  433.   andi.w  #7,D2          ; Kopieranweisungen berechnen
  434.   add.w   D2,D2
  435.   addq.l  #7,D0          ; plus 1 Block, falls unvollst. Block (< 32 Byte)
  436.   lsr.l   #3,D0          ; Anzahl kompletter 32-Byte-Bloecke [+ unvollst. Block]
  437.   jmp     loop32(PC,D2.w) ; ersten kompletten oder unvollst. Block loeschen
  438. loop32:                  ; jeweils 32 Byte loeschen
  439.   move.l  D1,(A0)+
  440.   move.l  D1,(A0)+
  441.   move.l  D1,(A0)+
  442.   move.l  D1,(A0)+
  443.   move.l  D1,(A0)+
  444.   move.l  D1,(A0)+
  445.   move.l  D1,(A0)+
  446.   move.l  D1,(A0)+
  447.   subq.l  #1,D0
  448.   bne.s   loop32         ; naechsten kompletten Block loeschen
  449. tstw:
  450.   move.w  A1,D2
  451.   btst    #1,D2          ; ein zusaetzliches Wort ?
  452.   beq.s   tstb           ; B: nein
  453.   move.w  D1,(A0)+
  454. tstb:
  455.   btst    #0,D2          ; ein zusaetzliches Byte ?
  456.   beq.s   ende           ; B: nein
  457.   move.b  D1,(A0)+
  458. ende:
  459. *)
  460.  CODE(6756H,1401H,0E14AH,1401H,3202H,4841H,3202H,3408H,0802H);
  461.  CODE(0000H,6704H,10C1H,5380H,3240H,0E488H,6726H,3400H);
  462.  CODE(4442H,0242H,0007H,0D442H,5E80H,0E688H,4EFBH,2002H);
  463.  CODE(20C1H,20C1H,20C1H,20C1H,20C1H,20C1H,20C1H,20C1H);
  464.  CODE(5380H,66ECH,3409H,0802H,0001H,6702H,30C1H,0802H);
  465.  CODE(0000H,6702H,10C1H);
  466.  
  467. #if (defined HM2)
  468. (*
  469.   move.w  (SP)+,D2
  470.   movea.l (SP)+,A0
  471. #if (defined __LONG_WHOLE__)
  472.   lea     12(SP),SP
  473. #else
  474.   lea     10(SP),SP
  475. #endif
  476.   jmp     (A0)
  477. *)
  478.  CODE(341FH,205FH);
  479. #if (defined __LONG_WHOLE__)
  480.  CODE(4FEFH,000CH);
  481. #else
  482.  CODE(4FEFH,000AH);
  483. #endif
  484.  CODE(4ED0H);
  485. #elif (defined TDIM2)
  486. (*
  487.   rts
  488. *)
  489.  CODE(4E75H);
  490. #endif
  491. END memset;
  492. __PROCFRAME_ON__
  493.  
  494. (*---------------------------------------------------------------------------*)
  495.  
  496. __PROCFRAME_OFF__
  497. PROCEDURE memchr ((* EIN/ -- *) src : ADDRESS;
  498.                   (* EIN/ -- *) val : CARDINAL;
  499.                   (* EIN/ -- *) len : sizeT    ): ADDRESS;
  500. (*T*)
  501. BEGIN
  502. #if (defined HM2)
  503. (*
  504.   move.l  D2,-(SP)
  505.   movea.l 8(SP),A0
  506. #if (defined __LONG_WHOLE__)
  507.   move.w  12+2(SP),D1
  508.   move.l  16(SP),D0
  509. #else
  510.   move.w  12(SP),D1
  511.   move.l  14(SP),D0
  512. #endif
  513. *)
  514.  CODE(2F02H,206FH,0008H);
  515. #if (defined __LONG_WHOLE__)
  516.  CODE(322FH,000EH,202FH,0010H);
  517. #else
  518.  CODE(322FH,000CH,202FH,000EH);
  519. #endif
  520. #elif (defined MM2)
  521. (*
  522.   move.l  -(A3),D0
  523. #if (defined __LONG_WHOLE__)
  524.   move.l  -(A3),D1
  525. #else
  526.   move.w  -(A3),D1
  527. #endif
  528.   movea.l -(A3),A0
  529.   tst.l   D0
  530. *)
  531.  CODE(2023H);
  532. #if (defined __LONG_WHOLE__)
  533.  CODE(2223H);
  534. #else
  535.  CODE(3223H);
  536. #endif
  537.  CODE(2063H,4A80H);
  538. #elif (defined TDIM2)
  539. (*
  540.   movea.l 10(SP),A0
  541.   move.w  8(SP),D1
  542.   move.l  4(SP),D0
  543. *)
  544.  CODE(206FH,000AH,322FH,0008H,202FH,0004H);
  545. #elif (defined LPRM2) || (defined SPCM2)
  546. (*
  547.   movea.l 18(A6),A0
  548.   move.w  16(A6),D1
  549.   move.l  12(A6),D0
  550. *)
  551.  CODE(206EH,0012H,322EH,0010H,202EH,000CH);
  552. #endif
  553.  
  554. (*
  555.   beq.s   ende
  556.  
  557.   subq.l  #1,D0
  558.   move.l  D0,D2
  559.   swap    D2
  560. lp:
  561.   cmp.b   (A0)+,D1
  562. start:
  563.   dbeq    D0,lp
  564.   dbeq    D2,lp
  565.   beq.s   found
  566.   moveq   #0,D0
  567.   bra.s   ende
  568. found:
  569.   move.l  A0,D0
  570.   subq.l  #1,D0
  571. ende:
  572. *)
  573.  CODE(671AH,5380H,2400H,4842H,0B218H,57C8H,0FFFCH,57CAH);
  574.  CODE(0FFF8H,6704H,7000H,6004H,2008H,5380H);
  575.  
  576. #if (defined HM2)
  577.  CODE(241FH);       (* move.l  (SP)+,D2 *)
  578.  CODE(205FH);       (* move.l  (SP)+,A0 *)
  579. #if (defined __LONG_WHOLE__)
  580.  CODE(4FEFH,000CH); (* lea     12(SP),SP *)
  581. #else
  582.  CODE(4FEFH,000AH); (* lea     10(SP),SP *)
  583. #endif
  584.  CODE(4ED0H);       (* jmp     (A0) *)
  585. #elif (defined MM2) && (defined __RES_ON_STACK__)
  586.  CODE(26C0H);       (* move.l  D0,(A3)+ *)
  587. #elif (defined LPRM2) || (defined SPCM2)
  588.  CODE(2D40H,0016H); (* move.l  D0,22(A6) *)
  589. #elif (defined TDIM2)
  590.  CODE(2F40H,000EH); (* move.l  D0,14(SP) *)
  591.  CODE(4E75H);       (* rts *)
  592. #endif
  593. END memchr;
  594. __PROCFRAME_ON__
  595.  
  596. (*---------------------------------------------------------------------------*)
  597.  
  598. __PROCFRAME_OFF__
  599. PROCEDURE memcmp ((* EIN/ -- *) blk1 : ADDRESS;
  600.                   (* EIN/ -- *) blk2 : ADDRESS;
  601.                   (* EIN/ -- *) len  : sizeT   ): INTEGER;
  602. (**)
  603. BEGIN
  604. #if (defined HM2)
  605. (*
  606.   move.w  D2,-(SP)
  607.   movea.l 6(SP),A0
  608.   movea.l 10(SP),A1
  609.   move.l  14(SP),D0
  610. *)
  611.  CODE(3F02H,206FH,0006H,226FH,000AH,202FH,000EH);
  612. #elif (defined MM2)
  613. (*
  614.   move.l  -(A3),D0
  615.   movea.l -(A3),A1
  616.   movea.l -(A3),A0
  617.   tst.l   D0
  618. *)
  619.  CODE(2023H,2263H,2063H,4A80H);
  620. #elif (defined TDIM2)
  621. (*
  622.   movea.l 12(SP),A0
  623.   movea.l 8(SP),A1
  624.   move.l  4(SP),D0
  625. *)
  626.  CODE(206FH,000CH,226FH,0008H,202FH,0004H);
  627. #elif (defined LPRM2) || (defined SPCM2)
  628. (*
  629.   movea.l 20(A6),A0
  630.   movea.l 16(A6),A1
  631.   move.l  12(A6),D0
  632. *)
  633.  CODE(206EH,0014H,226EH,0010H,202EH,000CH);
  634. #endif
  635.  
  636. (*
  637.   beq.s   equal
  638.   move.w  A0,D1
  639.   move.w  A1,D2
  640.   eor.b   D2,D1          ; genau eine der Adressen ungerade ?
  641.   btst    #0,D1          ;
  642.   beq.s   fastcmp        ; B: nein
  643. slowcmp:
  644.   cmpm.b  (A0)+,(A1)+
  645.   bne.s   notequal
  646.   subq.l  #1,D0
  647.   bne.s   slowcmp
  648.   bra.s   equal
  649.  
  650. fastcmp:
  651.   btst    #0,D2           ; beide Adressen ungerade ?
  652.   beq.s   longcnt         ; B: nein, beide gerade
  653.   cmpm.b  (A0)+,(A1)+     ; sonst ein Byte vergl. -> gerade Adr.
  654.   bne.s   notequal        ; B: schon das erste Byte unterschiedlich
  655.   subq.l  #1, D0          ; sonst ein Byte weniger zu vergleichen
  656. longcnt:
  657.   move.b  D0,D2           ; fuer Ueberhangtest
  658.   lsr.l   #2,D0           ; Anzahl zu vergleichender Langworte
  659.   beq.s   tstwcmp         ; B: weniger als 4 Bytes zu vergleichen
  660. cmplp:
  661.   cmpm.l  (A0)+,(A1)+
  662.   bne.s   notequal
  663.   subq.l  #1,D0
  664.   bne.s   cmplp
  665. tstwcmp:
  666.   btst    #1,D2           ; noch mindestens ein abschliessendes Wort vergl. ?
  667.   beq.s   tstbcmp         ; B: nein
  668.   cmpm.w  (A0)+,(A1)+     ; letztes Wort auch gleich ?
  669.   bne.s   notequal        ; B: nein
  670. tstbcmp:
  671.   btst    #0,D2           ; noch ein abschliessendes Byte vergl. ?
  672.   beq.s   equal           ; B: nein, Bloecke sind gleich
  673.   cmpm.b  (A0)+,(A1)+     ; letztes Byte auch gleich ?
  674.   bne.s   notequal        ; B: nein
  675. equal:
  676.   moveq   #0,D0
  677.   bra.s   ende
  678. notequal:
  679.   bhi.s   less            ; B: blk1 < blk2
  680.   moveq   #1,D0           ; sonst blk1 > blk2
  681.   bra.s   ende
  682. less:
  683.   moveq   #-1,D0
  684. ende:
  685. *)
  686.  CODE(6744H,3208H,3409H,0B501H,0801H,0000H,670AH,0B308H);
  687.  CODE(6638H,5380H,66F8H,602EH,0802H,0000H,6706H,0B308H);
  688.  CODE(6628H,5380H,1400H,0E488H,6708H,0B388H,661CH,5380H);
  689.  CODE(66F8H,0802H,0001H,6704H,0B348H,660EH,0802H,0000H);
  690.  CODE(6704H,0B308H,6604H,7000H,6008H,6204H,7001H,6002H);
  691.  CODE(70FFH);
  692.  
  693. #if (defined HM2)
  694.  CODE(341FH);       (* move.w  (SP)+,D2 *)
  695.  CODE(205FH);       (* move.l  (SP)+,A0 *)
  696.  CODE(4FEFH,000CH); (* lea     12(SP),SP *)
  697.  CODE(4ED0H);       (* jmp     (A0) *)
  698. #elif (defined MM2)
  699. #ifdef __RES_ON_STACK__
  700. #ifdef __LONG_WHOLE__
  701.  CODE(26C0H);       (* move.l  D0,(A3)+ *)
  702. #else
  703.  CODE(36C0H);       (* move.w  D0,(A3)+ *)
  704. #endif
  705. #endif
  706. #elif (defined LPRM2) || (defined SPCM2)
  707.  CODE(3D40H,0018H); (* move.w  D0,24(A6) *)
  708. #elif (defined TDIM2)
  709.  CODE(3F40H,0010H); (* move.w  D0,16(SP) *)
  710.  CODE(4E75H);       (* rts *)
  711. #endif
  712. END memcmp;
  713. __PROCFRAME_ON__
  714.  
  715. (*---------------------------------------------------------------------------*)
  716.  
  717. #if (defined LPRM2) || (defined SPCM2)
  718. PROCEDURE memalloc ((* EIN/ -- *)     size : sizeT;
  719.                     (* -- /AUS *) VAR old  : ADDRESS;
  720.                     (* -- /AUS *) VAR adr  : ADDRESS );
  721. (**)
  722. BEGIN
  723. (*
  724.   movea.l (SP)+,A6      ; A6 -> lokale Variablen des Aufrufers
  725.   movea.l (SP)+,A4      ; A4 -> globale Variablen des Aufrufers
  726.   movea.l (SP)+,A1      ; A1 := RTN-Adresse
  727.   movea.l (SP)+,A2      ; A2 -> <adr>
  728.   movea.l (SP)+,A0      ; A0 -> <old>
  729.   move.l  (SP)+,D0      ; D0 := <size>
  730.   move.l  SP,(A0)       ; <old> := Stackpointer vor Aufruf der Funktion
  731.   addq.l  #1,D0         ; <size> auf gerade Anzahl aufrunden
  732.   bclr    #0,D0         ;
  733.   suba.l  D0,SP         ; Neuer Stackpointer
  734.   move.l  SP,(A2)       ; <adr> := Neuer Stackpointer
  735.   jmp     (A1)          ; RETURN
  736. *)
  737.  CODE(2C5FH,285FH,225FH,245FH,205FH,201FH,208FH,5280H);
  738.  CODE(0880H,0000H,9FC0H,248FH,4ED1H);
  739. END memalloc;
  740.  
  741. (*---------------------------------------------------------------------------*)
  742.  
  743. PROCEDURE memdealloc ((* EIN/ -- *) old : ADDRESS );
  744. (*T*)
  745. BEGIN
  746. (*
  747.   movea.l (SP)+,A6      ; A6 -> lokale Variablen des Aufrufers
  748.   movea.l (SP)+,A4      ; A4 -> globale Variablen des Aufrufers
  749.   movea.l (SP)+,A1      ; A1 := RTN-Adresse
  750.   movea.l (SP),SP       ; Stack setzen
  751.   jmp     (A1)          ; RETURN
  752. *)
  753.  CODE(2C5FH,285FH,225FH,2E57H,4ED1H);
  754. END memdealloc;
  755.  
  756. #elif (defined TDIM2)
  757.  
  758. __PROCFRAME_OFF__
  759. PROCEDURE memalloc ((* EIN/ -- *)     size : sizeT;
  760.                     (* -- /AUS *) VAR old  : ADDRESS;
  761.                     (* -- /AUS *) VAR adr  : ADDRESS );
  762. (**)
  763. BEGIN
  764. (*
  765.   movea.l (SP)+,A1         ; A1 := RTN-Adresse
  766.   movea.l (SP)+,A2         ; A2 -> <adr>
  767.   movea.l (SP)+,A0         ; A0 -> <old>
  768.   move.l  (SP)+,D0         ; D0 := <size>
  769.   move.l  SP,(A0)          ; <old> := Stackpointer vor Aufruf der Funktion
  770.   addq.l  #1,D0            ; <size> auf gerade Anzahl aufrunden
  771.   bclr    #0,D0            ;
  772.   suba.l  D0,SP            ; Neuer Stackpointer
  773.   move.l  SP,(A2)          ; <adr> := Neuer Stackpointer
  774.   lea     -12(SP),SP       ; fuer Parameterkorrektur vom Aufrufer
  775.   jmp     (A1)             ; RETURN
  776. *)
  777.  CODE(225FH,245FH,205FH,201FH,208FH,5280H,0880H,0000H);
  778.  CODE(9FC0H,248FH,4FEFH,0FFF4H,4ED1H);
  779. END memalloc;
  780. __PROCFRAME_ON__
  781. (*---------------------------------------------------------------------------*)
  782. __PROCFRAME_OFF__
  783. PROCEDURE memdealloc ((* EIN/ -- *) old : ADDRESS );
  784. (*T*)
  785. BEGIN
  786. (*
  787.   movea.l (SP)+,A1         ; A1 := RTN-Adresse
  788.   movea.l (SP),SP          ; Stackpointer setzen
  789.   subq.l  #4,SP            ; fuer Parameterkorrektur vom Aufrufer
  790.   jmp     (A1)             ; RETURN
  791. *)
  792.  CODE(225FH,2E57H,598FH,4ED1H);
  793. END memdealloc;
  794. __PROCFRAME_ON__
  795.  
  796. #elif (defined HM2)
  797.  
  798. __PROCFRAME_OFF__
  799. PROCEDURE memalloc ((* EIN/ -- *)     size : sizeT;
  800.                     (* -- /AUS *) VAR old  : ADDRESS;
  801.                     (* -- /AUS *) VAR adr  : ADDRESS );
  802. (**)
  803. BEGIN
  804. (*
  805.   movea.l (SP)+,A1         ; A1 := RTN-Adresse
  806.   move.l  (SP)+,D0         ; D0 := <size>
  807.   movea.l (SP)+,A0         ; A0 -> <old>
  808.   move.l  (SP)+,D1         ; D1 -> <adr>
  809.   move.l  SP,(A0)          ; <old> := Stackpointer vor Aufruf der Funktion
  810.   addq.l  #1,D0            ; <size> auf gerade Anzahl aufrunden
  811.   bclr    #0,D0            ;
  812.   suba.l  D0,SP            ; Neuer Stackpointer
  813.   movea.l D1,A0            ; <adr> := Neuer Stackpointer
  814.   move.l  SP,(A0)          ;
  815.   jmp     (A1)             ; RETURN
  816. *)
  817.  CODE(225FH,201FH,205FH,221FH,208FH,5280H,0880H,0000H);
  818.  CODE(9FC0H,2041H,208FH,4ED1H);
  819. END memalloc;
  820. __PROCFRAME_ON__
  821. (*---------------------------------------------------------------------------*)
  822. __PROCFRAME_OFF__
  823. PROCEDURE memdealloc ((* EIN/ -- *) old : ADDRESS );
  824. (*T*)
  825. BEGIN
  826. (*
  827.   movea.l (SP)+,A1         ; A1 := RTN-Adresse
  828.   movea.l (SP),SP          ; Stackpointer setzen
  829.   jmp     (A1)             ; RETURN
  830. *)
  831.  CODE(225FH,2E57H,4ED1H);
  832. END memdealloc;
  833. __PROCFRAME_ON__
  834.  
  835. #elif (defined MM2)
  836.  
  837. __PROCFRAME_OFF__
  838. PROCEDURE memalloc ((* EIN/ -- *)     size : sizeT;
  839.                     (* -- /AUS *) VAR old  : ADDRESS;
  840.                     (* -- /AUS *) VAR adr  : ADDRESS );
  841. (**)
  842. BEGIN
  843.  ASSEMBLER
  844.    MOVEA.L -(A3),A2        ; A2 -> <adr>
  845.    MOVEA.L -(A3),A0        ; A0 -> <old>
  846.    MOVE.L  -(A3),D0        ; D0 := <size>
  847.    MOVEA.L (A7)+,A1        ; A1 := RTN-Adresse
  848.    MOVE.L  A7,(A0)         ; <old> := Stackpointer vor Aufruf der Funktion
  849.    ADDQ.L  #1,D0           ; <size> auf gerade Anzahl aufrunden
  850.    BCLR    #0,D0           ;
  851.    SUBA.L  D0,A7           ; Neuer Stackpointer
  852.    MOVE.L  A7,(A2)         ; <adr> := Neuer Stackpointer
  853.    JMP     (A1)            ; RETURN
  854.  END;
  855. END memalloc;
  856. __PROCFRAME_ON__
  857.  
  858. (*---------------------------------------------------------------------------*)
  859.  
  860. __PROCFRAME_OFF__
  861. PROCEDURE memdealloc ((* EIN/ -- *) old : ADDRESS );
  862. (*T*)
  863. BEGIN
  864.  ASSEMBLER
  865.    MOVEA.L (A7)+,A1        ; A1 := RTN-Adresse
  866.    MOVEA.L -(A3),A7        ; Stackpointer setzen
  867.    JMP     (A1)            ; RETURN
  868.  END;
  869. END memdealloc;
  870. __PROCFRAME_ON__
  871. #endif
  872.  
  873. END MEMBLK.
  874.